/*
 * Copyright (C) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {SpSystemTrace} from "../SpSystemTrace.js";
import {
    queryAnomalyData,
    queryConfigSysEventAppName,
    queryHisystemEventExits,
    queryMaxStateValue,
    queryPowerData,
    queryStateData,
    queryStateInitValue,
    querySyseventAppName,
    querySystemLocationData,
    querySystemLockData,
    querySystemSchedulerData
} from "../../database/SqlLite.js";
import {info} from "../../../log/Log.js";
import {TraceRow} from "../trace/base/TraceRow.js";
import {BaseStruct} from "../../bean/BaseStruct.js";
import {LitPopover} from "../../../base-ui/popover/LitPopoverV.js";
import {EnergyAnomalyRender, EnergyAnomalyStruct} from "../../database/ui-worker/ProcedureWorkerEnergyAnomaly.js";
import {EnergySystemStruct, EnergySystemRender} from "../../database/ui-worker/ProcedureWorkerEnergySystem.js";
import {EnergyPowerStruct, EnergyPowerRender} from "../../database/ui-worker/ProcedureWorkerEnergyPower.js";
import {EnergyStateStruct, EnergyStateRender} from "../../database/ui-worker/ProcedureWorkerEnergyState.js";
import {renders} from "../../database/ui-worker/ProcedureWorker.js";
import {EmptyRender} from "../../database/ui-worker/ProcedureWorkerCPU.js";

export class SpHiSysEventChart {
    static app_name: string | null
    private trace: SpSystemTrace;
    private energyTraceRow: TraceRow<BaseStruct> | undefined;

    constructor(trace: SpSystemTrace) {
        this.trace = trace;
    }

    async init() {
        let result = await queryHisystemEventExits();
        if (result.length <= 0) return;
        await this.initEnergyRow();
        await this.initAnomaly();
        await this.initSystem();
        await this.initPower();
        await this.initState();
    }

    private initEnergyRow = async () => {
        SpHiSysEventChart.app_name = '';
        let appNameFromTable = await querySyseventAppName();
        let configAppName = await queryConfigSysEventAppName();
        if (configAppName.length > 0 && appNameFromTable.length > 0) {
            let name = configAppName[0].process_name
            if (name != null) {
                let filterList = appNameFromTable.filter(appNameFromTableElement => {
                    return appNameFromTableElement.string_value?.trim() == name;
                })
                if (filterList.length > 0) {
                    SpHiSysEventChart.app_name = name
                }
            }
        }
        if (appNameFromTable.length > 0 &&  SpHiSysEventChart.app_name == "") {
            SpHiSysEventChart.app_name = appNameFromTable[0].string_value;
        }
        this.energyTraceRow = TraceRow.skeleton<any>();
        let radioList;
        let appNameList = this.energyTraceRow?.shadowRoot!.querySelector<LitPopover>("#appNameList");
        let addFlag = false;
        appNameList?.addEventListener('click', () => {
            let itemDiv = appNameList!.querySelector("div");
            if (!addFlag) {
                for (let index = 0; index < appNameFromTable.length; index++) {
                    let div = document.createElement("div");
                    div.setAttribute("style", "margin-bottom: 5px");
                    let appName = appNameFromTable[index].string_value;
                    // @ts-ignore
                    let formatAppName = "appName" + index;
                    div.setAttribute("id", formatAppName);
                    div.innerHTML = "<input class='radio'  name='processoption' " + (index == 0 ? "checked" : "") + " type='radio'" +
                        " app_name=" + formatAppName + " value= " + appName + ">" + appName;
                    itemDiv!.append(div);
                    this.energyTraceRow!.shadowRoot!.querySelector<HTMLDivElement>("#" + formatAppName)!.onclick = (e: any) => {
                        this.energyTraceRow?.shadowRoot!.querySelectorAll<HTMLInputElement>('input[type=radio][name=processoption]')!.forEach(item => {
                            if (item.checked) {
                                SpHiSysEventChart.app_name = item.getAttribute("value");
                            }
                        })
                        radioList = this.energyTraceRow?.shadowRoot!.querySelectorAll<HTMLInputElement>("input[type=radio][name=processoption]");
                        if (radioList != undefined) {
                            for (let index = 0; index < radioList.length; index++) {
                                if (e.path[0].id == radioList[index]!.getAttribute("app_name")) {
                                    SpHiSysEventChart.app_name = radioList[index]!.getAttribute("value");
                                    radioList[index]!.checked = true;
                                }
                            }
                        }
                        // @ts-ignore
                        appNameList!.visible = false
                        TraceRow.range!.refresh = true
                        this.trace.refreshCanvas(false)
                    }
                }
                addFlag = true;
            }
        })
        this.energyTraceRow.rowId = `energy`
        this.energyTraceRow.rowType = TraceRow.ROW_TYPE_ENERGY
        this.energyTraceRow.rowParentId = '';
        this.energyTraceRow.folder = true;
        this.energyTraceRow.name = 'Energy';
        this.energyTraceRow.style.height = '40px'
        this.energyTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler;
        this.energyTraceRow.selectChangeHandler = this.trace.selectChangeHandler;
        this.energyTraceRow.supplier = () => new Promise<Array<any>>((resolve) => resolve([]));
        this.energyTraceRow.onThreadHandler = (useCache) => {
            this.energyTraceRow?.canvasSave(this.trace.canvasPanelCtx!);
            if(this.energyTraceRow!.expansion){
                this.trace.canvasPanelCtx?.clearRect(0, 0, this.energyTraceRow!.frame.width, this.energyTraceRow!.frame.height);
            } else {
                (renders["empty"] as EmptyRender).renderMainThread(
                    {
                        context: this.trace.canvasPanelCtx,
                        useCache: useCache,
                        type: ``,
                    },
                    this.energyTraceRow!,
                );
            }
            this.energyTraceRow?.canvasRestore(this.trace.canvasPanelCtx!);
        }
        this.trace.rowsEL?.appendChild(this.energyTraceRow!)
    }

    private initAnomaly = async () => {
        let time = new Date().getTime()
        let anomalyTraceRow = TraceRow.skeleton<EnergyAnomalyStruct>();
        anomalyTraceRow.rowParentId = `energy`
        anomalyTraceRow.rowHidden = true
        anomalyTraceRow.rowId = "energy-anomaly"
        anomalyTraceRow.rowType = TraceRow.ROW_TYPE_ANOMALY_ENERGY
        anomalyTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler;
        anomalyTraceRow.selectChangeHandler = this.trace.selectChangeHandler;
        anomalyTraceRow.setAttribute("height", `55px`);
        let element = anomalyTraceRow.shadowRoot?.querySelector(".root") as HTMLDivElement;
        element!.style.height = `55px`;
        anomalyTraceRow.style.width = `100%`;
        anomalyTraceRow.setAttribute('children', '');
        anomalyTraceRow.name = "Anomaly Event";
        anomalyTraceRow.supplier = () => queryAnomalyData()
        anomalyTraceRow.focusHandler = ()=>{
            this.trace?.displayTip(anomalyTraceRow, EnergyAnomalyStruct.hoverEnergyAnomalyStruct, `<span>AnomalyName:${EnergyAnomalyStruct.hoverEnergyAnomalyStruct?.eventName||""}</span>`);
        }
        anomalyTraceRow.onThreadHandler = (useCache) => {
            let context = anomalyTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!;
            anomalyTraceRow.canvasSave( context);
            (renders["energyAnomaly"] as EnergyAnomalyRender).renderMainThread(
                {
                    context: context,
                    useCache: useCache,
                    type: `energyAnomaly`,
                    appName:SpHiSysEventChart.app_name||"",
                    canvasWidth:this.trace.canvasPanel?.width||0
                },
                anomalyTraceRow
            );
            anomalyTraceRow.canvasRestore( context);
        }
        this.trace.rowsEL?.appendChild(anomalyTraceRow)
        let durTime = new Date().getTime() - time;
        info('The time to load the anomaly is: ', durTime)
    }

    private initSystem = async () => {
        let time = new Date().getTime()
        let systemTraceRow = TraceRow.skeleton<EnergySystemStruct>();
        systemTraceRow.rowParentId = `energy`
        systemTraceRow.rowHidden = true
        systemTraceRow.rowId = "energy-system"
        systemTraceRow.rowType = TraceRow.ROW_TYPE_SYSTEM_ENERGY
        systemTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler;
        systemTraceRow.selectChangeHandler = this.trace.selectChangeHandler;
        systemTraceRow.setAttribute("height", `80px`);
        let element = systemTraceRow.shadowRoot?.querySelector(".root") as HTMLDivElement;
        element!.style.height = `90px`;
        systemTraceRow.style.width = `100%`;
        systemTraceRow.setAttribute('children', '');
        systemTraceRow.name = "System Event";
        systemTraceRow.supplier = () => Promise.all([querySystemLocationData(), querySystemLockData(), querySystemSchedulerData()]).then(result => {
            return this.getSystemData(result)
        })
        systemTraceRow.focusHandler = ()=>{
            this.trace?.displayTip(systemTraceRow, EnergySystemStruct.hoverEnergySystemStruct, `<div style="width: 250px">
                                <div style="display: flex"><div style="width: 75%;text-align: left">WORKSCHEDULER: </div><div style="width: 20%;text-align: left">${EnergySystemStruct.hoverEnergySystemStruct?.workScheduler! || 0}</div></div>
                                <div style="display: flex"><div style="width: 75%;text-align: left">POWER_RUNNINGLOCK: </div><div style="width: 20%;text-align: left">${EnergySystemStruct.hoverEnergySystemStruct?.power! || 0}</div></div>
                                <div style="display: flex"><div style="width: 75%;text-align: left">LOCATION: </div><div style="width: 20%;text-align: left">${EnergySystemStruct.hoverEnergySystemStruct?.location! || 0}</div></div>
                            </div>`);
        }
        systemTraceRow.onThreadHandler = (useCache) => {
            let context = systemTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!;
            systemTraceRow.canvasSave( context);
            (renders["energySystem"] as EnergySystemRender).renderMainThread(
                {
                    context: context,
                    useCache: useCache,
                    type: `energySystem`,
                },
                systemTraceRow
            );
            systemTraceRow.canvasRestore( context);
        }
        this.trace.rowsEL?.appendChild(systemTraceRow)
        let durTime = new Date().getTime() - time;
        info('The time to load the Ability Memory is: ', durTime)
    }

    getSystemData(result: any): Promise<any> {
        let systemDataList: any = {};
        if(result.length == 0){
            return Promise.resolve([]);
        }
        systemDataList[0] = this.handleLockData(result)
        systemDataList[1] = this.handleLocationData(result)
        systemDataList[2] = this.handleWorkData(result);
        return systemDataList
    }

    private handleLocationData(result: Array<Array<any>>){
        let locationIndex = -1;
        let locationCount = 0;
        let locationData: any[] = [];
        result[0].forEach((item: any) => {
            let da: any = {}
            if (item.Value == "stop") {
                if (locationIndex == -1) {
                    da.startNs = 0
                    da.count = 1
                } else {
                    da.startNs = item.ts
                    locationCount--;
                    da.count = locationCount
                }
                da.state = "stop"
            } else {
                da.startNs = item.ts
                locationCount++;
                da.count = locationCount
                da.state = "start"
            }
            locationIndex = 0
            da.type = 2
            locationData.push(da)
        })
        return locationData
    }

    private handleLockData(result: Array<Array<any>>){
        let lockCount = 0
        let tokedIds: Array<string> = []
        let lockData: any[] = []
        result[1].forEach((item: any) => {
            let running: any = {}
            let split = item.Value.split(",");
            if (item.Value.indexOf("ADD") > -1) {
                running.startNs = item.ts
                lockCount++;
                running.count = lockCount
                running.token = split[0].split("=")[1]
                running.type = 1
                tokedIds.push(running.token)
                lockData.push(running)
            } else {
                running.startNs = item.ts
                let toked = split[0].split("=")[1];
                let number = tokedIds.indexOf(toked);
                if(number > -1){
                    lockCount--;
                    running.count = lockCount
                    running.token = split[0].split("=")[1]
                    running.type = 1
                    lockData.push(running)
                    delete tokedIds[number]
                }
            }
        })

        return lockData
    }

    private handleWorkData(result: Array<Array<any>>) {
        let workDataArray = result[2];
        let workCountMap: Map<string, number> = new Map<string, number>();
        let nameIdMap: Map<string, Array<any>> = new Map<string, []>();
        let workData: any[] = []
        for (let i = 0; i < workDataArray.length; i++) {
            let dd: any = {}
            let item = workDataArray[i];
            let keys = item.appKey.split(",");
            let values = item.Value.split(",")
            for (let j = 0; j < keys.length; j++) {
                let key = keys[j]
                switch (key) {
                    case "NAME":
                        dd.appName = values[j]
                        break;
                    case "WORKID":
                        dd.workId = values[j]
                        break;
                }
            }
            if (item.eventName == "WORK_START") {
                let nameIdList = nameIdMap.get(dd.appName);
                let workCount = 0;
                if (nameIdList == undefined) {
                    workCount = 1;
                    nameIdMap.set(dd.appName, [dd.workId])
                } else {
                    nameIdList.push(dd.workId)
                    workCount = nameIdList.length;
                }
                let count = workCountMap.get(dd.appName)
                if (count == undefined) {
                    workCountMap.set(dd.appName, 1);
                } else {
                    workCountMap.set(dd.appName, count + 1);
                }
                dd.startNs = item.ts
                dd.count = workCount;
                dd.type = 0
                workData.push(dd)
            } else if (item.eventName == "WORK_STOP") {
                let nameIdList: any = nameIdMap.get(dd.appName);
                let index =  nameIdList.indexOf(dd.workId);
                if (nameIdList != undefined &&  index> -1) {
                    delete nameIdList[index];
                    let workCount = workCountMap.get(dd.appName)
                    if (workCount != undefined) {
                        workCount = workCount - 1;
                        workCountMap.set(dd.appName, workCount)
                        dd.startNs = item.startNS;
                        dd.count = workCount;
                        dd.type = 0
                        workData.push(dd)
                    }
                }
            }
        }
        return workData
    }

    private initPower = async () => {
        let time = new Date().getTime();
        let powerTraceRow = TraceRow.skeleton<EnergyPowerStruct>();
        powerTraceRow.rowParentId = `energy`
        powerTraceRow.rowHidden = true
        powerTraceRow.rowId = "energy-power"
        powerTraceRow.rowType = TraceRow.ROW_TYPE_POWER_ENERGY
        powerTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler;
        powerTraceRow.selectChangeHandler = this.trace.selectChangeHandler;
        powerTraceRow.setAttribute("height", `200px`);
        let element = powerTraceRow.shadowRoot?.querySelector(".root") as HTMLDivElement;
        element!.style.height = `200px`;
        powerTraceRow.style.width = `100%`;
        powerTraceRow.setAttribute('children', '');
        powerTraceRow.name = "Power"
        powerTraceRow.supplier = () => queryPowerData().then(items => {
            return this.getPowerData(items)
        })
        powerTraceRow.focusHandler = ()=>{
            this.trace?.displayTip(powerTraceRow, EnergyPowerStruct.hoverEnergyPowerStruct, `<div style="width: 120px">
                            <div style="display: flex"><div style="width: 80%;text-align: left">CPU: </div><div style="width: 20%;text-align: left">${EnergyPowerStruct.hoverEnergyPowerStruct?.cpu! || 0}</div></div>
                            <div style="display: flex"><div style="width: 80%;text-align: left">location: </div><div style="width: 20%;text-align: left">${EnergyPowerStruct.hoverEnergyPowerStruct?.location! || 0}</div></div>
                            <div style="display: flex"><div style="width: 80%;text-align: left">GPU: </div><div style="width: 20%;text-align: left">${EnergyPowerStruct.hoverEnergyPowerStruct?.gpu! || 0}</div></div>
                            <div style="display: flex"><div style="width: 80%;text-align: left">display: </div><div style="width: 20%;text-align: left">${EnergyPowerStruct.hoverEnergyPowerStruct?.display! || 0}</div></div>
                            <div style="display: flex"><div style="width: 80%;text-align: left">camera: </div><div style="width: 20%;text-align: left">${EnergyPowerStruct.hoverEnergyPowerStruct?.camera! || 0}</div></div>
                            <div style="display: flex"><div style="width: 80%;text-align: left">bluetooth: </div><div style="width: 20%;text-align: left">${EnergyPowerStruct.hoverEnergyPowerStruct?.bluetooth! || 0}</div></div>
                            <div style="display: flex"><div style="width: 80%;text-align: left">flashlight: </div><div style="width: 20%;text-align: left">${EnergyPowerStruct.hoverEnergyPowerStruct?.flashlight! || 0}</div></div>
                            <div style="display: flex"><div style="width: 80%;text-align: left">audio: </div><div style="width: 20%;text-align: left">${EnergyPowerStruct.hoverEnergyPowerStruct?.audio! || 0}</div></div>
                            <div style="display: flex"><div style="width: 80%;text-align: left">wifiScan: </div><div style="width: 20%;text-align: left">${EnergyPowerStruct.hoverEnergyPowerStruct?.wifiscan! || 0}</div></div>
                        </div>`);
        }
        powerTraceRow.onThreadHandler = (useCache) => {
            let context = powerTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!;
            powerTraceRow.canvasSave( context);
            (renders["energyPower"] as EnergyPowerRender).renderMainThread(
                {
                    context: context,
                    useCache: useCache,
                    type: `energyPower`,
                    appName:SpHiSysEventChart.app_name||""
                },
                powerTraceRow
            );
            powerTraceRow.canvasRestore( context);
        }
        this.trace.rowsEL?.appendChild(powerTraceRow)
        let durTime = new Date().getTime() - time;
        info('The time to load the energy power is: ', durTime)
    }

    async getPowerData(items: any): Promise<any> {
        let powerDataMap: any = {}
        let appNameList: any = []
        items.forEach((item: any) => {
            let dataItem = powerDataMap[item.startNS]
            if (dataItem == undefined) {
                if (item.appKey == "APPNAME") {
                    let appMap: any = {};
                    let appNames = item.eventValue.split(",")
                    appNameList = appNames;
                    if (appNames.length > 0) {
                        for (let appNamesKey of appNames) {
                            appMap[appNamesKey] = new EnergyPowerStruct()
                            appMap[appNamesKey].name = appNamesKey
                            appMap[appNamesKey].ts = item.startNS
                        }
                        powerDataMap[item.startNS] = appMap;
                    }
                }
            } else {
                if (item.appKey != "APPNAME") {
                    let values = item.eventValue.split(",")
                    for (let i = 0; i < values.length; i++) {
                        let appName = appNameList[i]
                        let obj = dataItem[appName]
                        if (obj != undefined) {
                            let eventName = item.eventName.split("_");
                            let s = eventName[eventName.length - 1].toLocaleLowerCase();
                            if (obj[s] == undefined) {
                                obj[s] = parseInt(values[i])
                            } else {
                                obj[s] += parseInt(values[i])
                            }
                        }
                    }
                } else {
                    let dataMap = powerDataMap[item.startNS];
                    let appNames = item.eventValue.split(",")
                    appNameList = appNames;
                    if (appNames.length > 0) {
                        for (let appNamesKey of appNames) {
                            dataMap[appNamesKey] = new EnergyPowerStruct()
                            dataMap[appNamesKey].name = appNamesKey
                            dataMap[appNamesKey].ts = item.startNS
                        }
                    }
                }
            }
        })
        return Object.values(powerDataMap)
    }


    private initState = async () => {
        let time = new Date().getTime();
        let stateList = ["Brightness Nit", "Signal Level", "Wifi Event Received", "Audio Stream Change",
            "Audio Volume Change", "Wifi State", "Bluetooth Br Switch State", "Location Switch State", "Sensor State"]
        let stateName = ["BRIGHTNESS_NIT", "SIGNAL_LEVEL", "WIFI_EVENT_RECEIVED", "AUDIO_STREAM_CHANGE",
            "AUDIO_VOLUME_CHANGE", "WIFI_STATE", "BLUETOOTH_BR_SWITCH_STATE", "LOCATION_SWITCH_STATE", "SENSOR_STATE"]
        let initValueList = ["brightness", "nocolumn", "nocolumn", "nocolumn", "nocolumn", "wifi", "bt_state", "location", "nocolumn"]

        for (let index = 0; index < stateList.length; index++) {
            let maxStateData = await queryMaxStateValue(stateName[index])
            if (!maxStateData[0]) {
                continue;
            }
            let maxStateTotal = maxStateData[0].maxValue.toString()
            if (maxStateData[0].type.toLocaleLowerCase().includes("state") &&　maxStateData[0].type.toLocaleLowerCase()　!= ("bluetooth_br_switch_state")) {
                if (maxStateData[0].maxValue == 0) {
                    maxStateTotal = "enable"
                } else {
                    maxStateTotal = "disable"
                }
            }
            let stateTraceRow = TraceRow.skeleton<EnergyStateStruct>();
            stateTraceRow.rowParentId = `energy`
            stateTraceRow.rowHidden = true
            stateTraceRow.rowId = "energy-state"
            stateTraceRow.rowType = TraceRow.ROW_TYPE_STATE_ENERGY
            stateTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler;
            stateTraceRow.selectChangeHandler = this.trace.selectChangeHandler;
            stateTraceRow.style.height = '40px'
            stateTraceRow.style.width = `100%`;
            stateTraceRow.setAttribute('children', '');
            stateTraceRow.name = `${stateList[index]}`
            stateTraceRow.supplier = () => Promise.all([queryStateInitValue(stateName[index], initValueList[index]), queryStateData(stateName[index])]).then(result => {
                let stateInitValue = initValueList[index] == "nocolumn" ? [] : result[0];
                return stateInitValue.concat(result[1]);
            })
            stateTraceRow.focusHandler = ()=>{
                let tip = "";
                if (EnergyStateStruct.hoverEnergyStateStruct?.type!.toLocaleLowerCase().includes("state")) {
                    tip = `<span>Switch Status: ${EnergyStateStruct.hoverEnergyStateStruct?.value == 1 ? 'disable' : 'enable'}</span>`
                    if (EnergyStateStruct.hoverEnergyStateStruct?.type!.toLocaleLowerCase() == "bluetooth_br_switch_state") {
                        tip = `<span>${SpHiSysEventChart.getBlueToothState(EnergyStateStruct.hoverEnergyStateStruct?.value)}</span>`
                    }
                } else {
                    tip = `<span>value: ${EnergyStateStruct.hoverEnergyStateStruct?.value || 0}</span>`
                }
                this.trace?.displayTip(stateTraceRow, EnergyStateStruct.hoverEnergyStateStruct, tip);
            }
            stateTraceRow.onThreadHandler = (useCache) => {
                let context = stateTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!;
                stateTraceRow.canvasSave( context);
                (renders["energyState"] as EnergyStateRender).renderMainThread(
                    {
                        context: context,
                        useCache: useCache,
                        type: `energyState${index}`,
                        maxState: maxStateData[0].maxValue,
                        maxStateName: maxStateData[0].type.toLocaleLowerCase()　== ("bluetooth_br_switch_state")? "-1" : maxStateTotal.toString()
                    },
                    stateTraceRow
                );
                stateTraceRow.canvasRestore( context);
            }
            this.trace.rowsEL?.appendChild(stateTraceRow)
            let durTime = new Date().getTime() - time;
            info('The time to load the Ability Memory is: ', durTime)
        }
    }

    public static getBlueToothState(num: number | undefined): string{
        switch (num) {
            case 0:
                return "STATE_TURNING_ON";
            case 1:
                return "STATE_TURN_ON";
            case 2:
                return "STATE_TURNING_OFF";
            case 3:
                return "STATE_TURN_OFF";
            default:
                return "UNKNOWN_STATE";
        }
    }
}
